const { app, BrowserWindow, ipcMain, dialog, Notification } = require('electron');
const path = require('path');
const fs = require('fs');
const ElectronStore = require('electron-store');

// 创建数据存储实例
const store = new ElectronStore({
  name: 'schedule-data'
});

let mainWindow;

function createWindow() {
  // 创建主窗口
  mainWindow = new BrowserWindow({
    width: 1200,
    height: 800,
    // 窗口配置
    frame: true,
    roundedCorners: true,
    backgroundColor: '#ffffff',
    // 性能配置
    hardwareAcceleration: true,
    // 图标设置
    icon: path.join(__dirname, 'cccf9-1p5f5-001.ico'),
    // 界面配置
    autoHideMenuBar: true,
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      contextIsolation: true,
      enableRemoteModule: false,
      nodeIntegration: false
    },
    title: '智能日程管理'
  });
  
  // 窗口焦点事件
  mainWindow.on('focus', () => {});

  // 加载应用页面
  mainWindow.loadFile('index.html');

  // 开发者工具（已注释）


  // 窗口关闭事件
  mainWindow.on('closed', () => {
    mainWindow = null;
  });
}

// 保存数据IPC处理
ipcMain.handle('save-data', (event, data) => {
  try {
    // 存储主要数据
    store.set('schedules', data);
    
    // 数据备份（可选）
    try {
      const userDataPath = app.getPath('userData');
      const backupDir = path.join(userDataPath, 'backups');
      const backupPath = path.join(backupDir, 'schedules_backup.json');
      
      // 确保目录存在
      if (!fs.existsSync(backupDir)) {
        fs.mkdirSync(backupDir, { recursive: true });
      }
      
      // 生成备份数据
      const backupData = {
        version: '1.0',
        exportDate: new Date().toISOString(),
        schedules: data
      };
      
      // 写入备份
      fs.writeFileSync(backupPath, JSON.stringify(backupData, null, 2));
    } catch (backupError) {
      // 备份失败不影响核心功能
      console.log('备份失败（不影响主功能）:', backupError.message);
    }
    
    return { success: true };
  } catch (error) {
    console.error('保存数据失败:', error);
    return { success: false, error: error.message };
  }
});

// 读取数据IPC处理
ipcMain.handle('load-data', () => {
  try {
    // 读取存储数据
    const schedules = store.get('schedules', []);
    return { success: true, data: schedules };
  } catch (error) {
    console.error('读取数据失败:', error);
    return { success: false, error: error.message, data: [] };
  }
});

// 导出数据IPC处理
ipcMain.handle('export-data', async (event, dataStr) => {
  try {
    // 获取数据目录
    const userDataPath = app.getPath('userData');
    const archiveDir = path.join(userDataPath, 'archives');
    
    // 确保目录存在
    if (!fs.existsSync(archiveDir)) {
      fs.mkdirSync(archiveDir, { recursive: true });
    }
    
    // 生成时间戳文件名
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const defaultFileName = `schedule_backup_${timestamp}.json`;
    
    const result = await dialog.showSaveDialog(mainWindow, {
      title: '导出数据',
      defaultPath: path.join(archiveDir, defaultFileName),
      filters: [
        { name: 'JSON文件', extensions: ['json'] }
      ]
    });

    if (!result.canceled && result.filePath) {
      fs.writeFileSync(result.filePath, dataStr);
      return { success: true };
    }
    return { success: false };
  } catch (error) {
    console.error('导出数据失败:', error);
    return { success: false, error: error.message };
  }
});

// 导入数据IPC处理
ipcMain.handle('import-data', async () => {
  try {
    // 获取存档目录
    const userDataPath = app.getPath('userData');
    const archiveDir = path.join(userDataPath, 'archives');
    
    // 确保目录存在
    if (!fs.existsSync(archiveDir)) {
      fs.mkdirSync(archiveDir, { recursive: true });
    }
    
    const result = await dialog.showOpenDialog(mainWindow, {
      title: '导入数据',
      defaultPath: archiveDir, // 默认打开存档文件夹
      filters: [
        { name: 'JSON文件', extensions: ['json'] }
      ],
      properties: ['openFile']
    });

    if (!result.canceled && result.filePaths.length > 0) {
      const dataStr = fs.readFileSync(result.filePaths[0], 'utf8');
      const data = JSON.parse(dataStr);
      return { success: true, data };
    }
    return { success: false };
  } catch (error) {
    console.error('导入数据失败:', error);
    return { success: false, error: error.message };
  }
});

// 应用就绪事件
app.whenReady().then(() => {
  createWindow();

  // macOS激活事件
  app.on('activate', () => {
    if (BrowserWindow.getAllWindows().length === 0) createWindow();
  });
});

// 显示通知IPC处理
ipcMain.handle('show-notification', (event, title, options) => {
  try {
    // 检查通知支持
    if (Notification.isSupported()) {
      const notification = new Notification({
        title,
        ...options,
        // 通知配置
        hasReply: options.hasReply || false,
        urgency: 'critical'
      });
      
      // 通知点击事件
      notification.on('click', () => {
        if (mainWindow) {
          mainWindow.show();
          mainWindow.focus();
        }
      });
      
      notification.show();
      return { success: true };
    }
    return { success: false, error: '通知功能不受支持' };
  } catch (error) {
    console.error('显示通知失败:', error);
    return { success: false, error: error.message };
  }
});

// 请求通知权限IPC处理
ipcMain.handle('request-notification-permission', async () => {
  try {
    if (Notification.isSupported()) {
      // Electron中通知权限通常自动授予
      return { success: true, permission: 'granted' };
    }
    return { success: false, error: '通知功能不受支持' };
  } catch (error) {
    console.error('请求通知权限失败:', error);
    return { success: false, error: error.message };
  }
});

// 窗口全部关闭事件
app.on('window-all-closed', () => {
  if (process.platform !== 'darwin') app.quit();
});